home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 22 / AACD 22.iso / AACD / Programming / powerd / source / dmod.d < prev    next >
Encoding:
Text File  |  2001-01-27  |  11.2 KB  |  530 lines
  1. // view powerd binary module (#?.b) generated by powerd v0.12
  2.  
  3. // 1.0 initial release
  4. // 1.1 (27.1.2001) added unions (in binary modules introduced with PowerD 0.17)
  5.  
  6. BYTE 0,0,'$VER:dmod v1.1 by MarK (27.1.2001)',0,0
  7.  
  8. PROC DisplayMODULE(mem:PTR TO CHAR)
  9.     DEF    ver,rev,count,nl,ml,namelist:PTR TO CHAR,type,flags,acount,rcount,l,offset,
  10.             base:PTR TO CHAR
  11.  
  12.     IF Long(mem)<>"DMOD"
  13.         PrintF('\s: unknown filetype','dmod')
  14.         RETURN
  15.     ENDIF
  16.     mem+=4                        // skip "DMOD"
  17.     ver:=Word(mem)
  18.     rev:=Word(mem+2)
  19.     mem+=4                        // skip ver,rev
  20.     PrintF('// requied version of powerd: v\d.\z\d[2]\n\n',ver,rev)
  21.  
  22.     IF Long(mem)="MODS"
  23.         PrintF('MODULE\t')
  24.         count:=Word(mem+4)
  25.         mem+=6
  26.         WHILE count
  27.             count--
  28.             nl:=Word(mem)
  29.             mem+=2
  30.             PrintF('''\s''',mem)
  31.             mem+=nl+1
  32.             IF Odd(mem) THEN mem++
  33.             IF CtrlC() THEN RETURN
  34.         EXITIF count=0 DO PrintF('\n\n')
  35.             PrintF(',\n\t\t\t')
  36.         ENDWHILE
  37.     ENDIF
  38.  
  39.     IF Long(mem)="CNST"                // constant list
  40.         PrintF('CONST\t')
  41.         count:=Word(mem+4)            // count of constants
  42.         ml:=Long(mem+6)
  43.         nl:=Long(mem+10)
  44.         mem+=14
  45.         namelist:=mem+ml
  46.         WHILE count
  47.             count--
  48.             PrintF('\s=',namelist)
  49.             type:=UByte(mem++)
  50.             flags:=UByte(mem++)
  51.             IF type=$ff
  52.                 PrintF('0')
  53.             ELSEIF type=8                // DT_DOUBLE
  54.                 PrintF('$\z\h[8].\z\h[8]',Long(mem),Long(mem+4))
  55.                 mem+=8
  56.             ELSEIF flags&%10            // S_TAG
  57.                 PrintF('$\h',Word(mem)|$80000000)
  58.                 mem+++
  59.             ELSEIF type=3                // DT_WORD
  60.                 PrintF('\d',Word(mem))
  61.                 mem+++
  62.             ELSE
  63.                 acount:=Long(mem)
  64.                 PrintF(IF acount>=-32768 AND acount<=32767 THEN '\d' ELSE '$\h',acount)
  65. //                PrintF(IF Long(mem)>=-32768 AND Long(mem)<=32767 THEN '\d' ELSE '$\h',Long(mem))
  66.                 mem+=4
  67.             ENDIF
  68.             namelist+=StrLen(namelist)+1
  69.             IF namelist[0]="\0" THEN namelist++
  70.             IF CtrlC() THEN RETURN
  71.         EXITIF count=0 DO PrintF('\n\n')
  72.             PrintF(',\n\t\t')
  73.         ENDWHILE
  74.         IF Odd(namelist) THEN namelist++
  75.         mem:=namelist
  76.     ENDIF
  77.  
  78.     IF Long(mem)="OBJC"            -> object list
  79.         ml:=Long(mem+4)
  80.         nl:=Long(mem+8)
  81.         acount:=Word(mem+12)
  82.         count:=Word(mem+14)
  83.         mem+=16
  84.         namelist:=mem+ml
  85.  
  86.         WHILE acount
  87.             mem,namelist:=LoadOBJECT(mem,namelist)
  88.             acount--
  89.             IF CtrlC() THEN RETURN
  90.         ENDWHILE
  91.  
  92.         IF Odd(namelist) THEN namelist++
  93.         mem:=namelist
  94.     ENDIF
  95.  
  96.     IF Long(mem)="#def"            -> #define list
  97.         count:=Word(mem+4)
  98.         acount:=Word(mem+6)
  99.         ml:=Long(mem+8)
  100.         nl:=Long(mem+12)
  101.         mem+=16
  102.         namelist:=mem+ml
  103.  
  104.         WHILE count
  105.             count--
  106.             PrintF('#define \s',namelist)
  107.             namelist+=mem[1]+1
  108.             l:=Word(mem+2)
  109.             acount:=mem[0]
  110.             mem+=4
  111.             IF acount
  112.                 PrintF('(')
  113.                 WHILE acount
  114.                     PrintF('\s',namelist)
  115.                     namelist+=mem[1]+1
  116.                     mem+++
  117.                     acount--
  118.                     IF CtrlC() THEN RETURN
  119.                 EXITIF acount=0 DO PrintF(') ')
  120.                     PrintF(',')
  121.                 ENDWHILE
  122.             ELSE PrintF(' ')
  123.             PrintF('\s\n',namelist)
  124.             namelist+=l+1
  125.             IF CtrlC() THEN RETURN
  126.         ENDWHILE
  127.  
  128.         IF Odd(namelist) THEN namelist++
  129.         mem:=mem+nl
  130.     ENDIF
  131.  
  132.     IF Long(mem)="LIBR"            // function list
  133.         count:=Word(mem+4)        // count of functions
  134.         nl:=Word(mem+6)            // base name length
  135.         ml:=Long(mem+12)            // block length
  136.         mem+=16
  137.         base:=mem
  138.         mem+=nl
  139.         IF mem[0]="\0" THEN mem++
  140.         namelist:=mem+ml
  141.         PrintF('LIBRARY \s\n\t',base)
  142.  
  143.         WHILE count
  144.             count--
  145.             offset:=Word(mem)
  146.             acount:=mem[2]
  147.             rcount:=mem[3]&$1f
  148.             ver:=mem[3]>>5            // get ppc function type
  149.             SELECT ver
  150.             CASE 0;    PrintF('M68K,')
  151.             CASE 1;    PrintF('PPC,')
  152.             CASE 2;    PrintF('PPC2,')
  153.             CASE 3;    PrintF('PPC0,')
  154.             ENDSELECT
  155.             mem+=4
  156.             PrintF('\s(',namelist)
  157.             namelist+=StrLen(namelist)+1
  158.             WHILE acount
  159.                 acount--
  160.                 IF ver
  161.                     SELECT mem[2]
  162.                     CASE 0 TO 31;    PrintF('r\d',mem[2]&%11111)
  163.                     CASE 32 TO 63;    PrintF('f\d',mem[2]&%11111)
  164.                     ENDSELECT
  165.                 ELSE
  166.                     SELECT mem[2]
  167.                     CASE 0 TO 7;    PrintF('d\d',mem[2]&%111)
  168.                     CASE 8 TO 15;    PrintF('a\d',mem[2]&%111)
  169.                     CASE 16 TO 23;    PrintF('fp\d',mem[2]&%111)
  170.                     ENDSELECT
  171.                 ENDIF
  172.                 type:=mem[0]
  173.                 flags:=mem[1]        // means default value set
  174.                 nl:=mem[3]
  175.                 mem+=4
  176.                 IF flags
  177.                     IF type=8
  178.                         PrintF('=$\z\h[8].\z\h[8]',Long(mem),Long(mem+4))
  179.                         mem+=8
  180.                     ELSE
  181.                         PrintF('=$\d',Long(mem))
  182.                         mem+=4
  183.                     ENDIF
  184.                 ENDIF
  185.                 IF type
  186.                     PrintF(':\s',TypeStr(type))
  187.                 ENDIF
  188.                 IF nl
  189.                     PrintF('\s',namelist)
  190.                     namelist+=nl+1
  191.                 ENDIF
  192.             EXITIF acount=0
  193.                 PrintF(',')
  194.                 IF CtrlC() THEN RETURN
  195.             ENDWHILE
  196.             PrintF(')')
  197.  
  198.             IF rcount
  199.                 PrintF('(')
  200.                 WHILE rcount
  201.                     rcount--
  202.                     IF ver
  203.                         SELECT mem[2]
  204.                         CASE 0 TO 31;    PrintF('r\d',mem[2]&%11111)
  205.                         CASE 32 TO 63;    PrintF('f\d',mem[2]&%11111)
  206.                         ENDSELECT
  207.                     ELSE
  208.                         SELECT mem[2]
  209.                         CASE 0 TO 7;    PrintF('d\d',mem[2]&%111)
  210.                         CASE 8 TO 15;    PrintF('a\d',mem[2]&%111)
  211.                         CASE 16 TO 23;    PrintF('fp\d',mem[2]&%111)
  212.                         ENDSELECT
  213.                     ENDIF
  214.                     type:=mem[0]
  215.                     nl:=mem[3]
  216.                     mem+=4
  217.                     IF type
  218.                         PrintF(':\s',TypeStr(type))
  219.                     ENDIF
  220.                     IF nl
  221.                         PrintF('\s',namelist)
  222.                         namelist+=nl+1
  223.                     ENDIF
  224.                 EXITIF rcount=0 DO PrintF(')')
  225.                     PrintF(',')
  226.                     IF CtrlC() THEN RETURN
  227.                 ENDWHILE
  228.             ENDIF
  229.             PrintF('=\d',offset)
  230.             IF CtrlC() THEN RETURN
  231.         EXITIF count=0 DO PrintF('\n\n')
  232.             PrintF(',\n\t')
  233.         ENDWHILE
  234.         IF Odd(namelist) THEN namelist++
  235.         mem:=namelist
  236.     ENDIF
  237.  
  238.     IF Long(mem)="EXPR"            // external function list
  239.         count:=Word(mem+4)
  240.         ml:=Long(mem+10)
  241.         nl:=Long(mem+14)
  242.         mem+=18
  243.         namelist:=mem+ml
  244.  
  245.         WHILE count
  246.             count--
  247.             SELECT type:=mem[0]
  248.             CASE 11;    PrintF('EPROC')
  249.             CASE 13;    PrintF('LPROC')
  250.             CASE 14;    PrintF('RPROC')
  251.             ENDSELECT
  252. /*
  253.             IF StrCmp(namelist,'Ror')
  254.                 xxxxxx:
  255.                 l:=l
  256.             ENDIF
  257. */
  258.             PrintF(' \s(',namelist)
  259.             namelist+=StrLen(namelist)+1
  260.             flags:=mem[1]
  261.             acount:=mem[2]
  262.             rcount:=mem[3]
  263.             mem+=4
  264.             offset:=0
  265.             IF flags&%01
  266.                 offset:=namelist
  267.                 namelist+=StrLen(namelist)+1
  268.             ENDIF
  269.  
  270.             IF type=14
  271.                 IF flags&%10
  272.                     l:=namelist
  273.                     namelist+=StrLen(namelist)+1
  274.                 ELSE
  275.                     l:=NIL
  276.                 ENDIF
  277.             ENDIF
  278.  
  279.             WHILE acount
  280.                 acount--
  281.                 type:=mem[0]
  282.                 flags:=mem[1]
  283.                 SELECT mem[3]
  284.                 CASE 0 TO 7;    PrintF('d\d',mem[3]&%111)
  285.                 CASE 8 TO 15;    PrintF('a\d',mem[3]&%111)
  286.                 CASE 16 TO 23;    PrintF('fp\d',mem[3]&%111)
  287.                 DEFAULT;            PrintF('\c',"z"-acount)        // stack
  288.                 ENDSELECT
  289.                 mem+=4
  290.                 IF flags&%01
  291.                     IF type=8    // DT_DOUBLE
  292.                         PrintF('=$\z\h[8].\z\h[8]',Long(mem),Long(mem+4))
  293.                         mem+=8
  294.                     ELSE
  295.                         PrintF('=\d',Long(mem))
  296.                         mem+=4
  297.                     ENDIF
  298.                 ENDIF
  299.                 IF type
  300.                     PrintF(':\s',TypeStr(type))
  301.                     IF flags&%10
  302.                         PrintF('\s',namelist)
  303.                         namelist+=StrLen(namelist)+1
  304.                     ENDIF
  305.                 ENDIF
  306.             EXITIF acount=0
  307.                 PrintF(',')
  308.                 IF CtrlC() THEN RETURN
  309.             ENDWHILE
  310.             PrintF(')')
  311.  
  312.             IF rcount
  313.                 PrintF('(')
  314.                 WHILE rcount
  315.                     rcount--
  316.                     type:=mem[0]
  317.                     SELECT mem[1]
  318.                     CASE 0 TO 7;    PrintF('d\d',mem[1]&%111)
  319.                     CASE 8 TO 15;    PrintF('a\d',mem[1]&%111)
  320.                     CASE 16 TO 23;    PrintF('fp\d',mem[1]&%111)
  321.                     ENDSELECT
  322.                     mem+++
  323.                     IF type THEN PrintF(':\s',TypeStr(type))
  324.                     IF type=10 OR type=42 OR type=74 OR type=138
  325.                         PrintF('\s',namelist)
  326.                         namelist+=StrLen(namelist)+1
  327.                     ENDIF
  328.                 EXITIF rcount=0 DO PrintF(')')
  329.                     PrintF(',')
  330.                     IF CtrlC() THEN RETURN
  331.                 ENDWHILE
  332.             ENDIF
  333.  
  334.             IF offset THEN PrintF(' OF \s',offset)
  335.             IF l THEN PrintF('=''\s''',l)
  336.             IF CtrlC() THEN RETURN
  337.             PrintF('\n')
  338.         ENDWHILE
  339.         PrintF('\n')
  340.         IF Odd(namelist) THEN namelist++
  341.         mem+=nl
  342.     ENDIF
  343.  
  344.     IF Long(mem)="EDEF"
  345.         PrintF('EDEF\t')
  346.         count:=Word(mem+4)
  347.         ml:=Long(mem+6)
  348.         nl:=Long(mem+10)
  349.         mem+=14
  350.         namelist:=mem+ml
  351.  
  352.         WHILE count
  353.             count--
  354.             PrintF('\s',namelist)
  355.             namelist+=StrLen(namelist)+1
  356.             IF mem[0] THEN PrintF(':\s',TypeStr(mem[0]))
  357.             IF mem[1]
  358.                 PrintF('\s',namelist)
  359.                 namelist+=StrLen(namelist)+1
  360.             ENDIF
  361.             mem+++
  362.         EXITIF count=0 DO PrintF('\n\n')
  363.             PrintF(',\n\t\t')
  364.             IF CtrlC() THEN RETURN
  365.         ENDWHILE
  366.         mem+=nl
  367.     ENDIF
  368.  
  369.     IF Long(mem)="LINK"
  370.         PrintF('OPT\t')
  371.         count:=Word(mem+4)
  372.         mem:=mem+6
  373.         WHILE count
  374.             count--
  375.             nl:=Word(mem)
  376.             mem+++
  377.             PrintF('''\s''',mem)
  378.             mem:=mem+nl
  379.             IF Odd(nl) THEN mem++
  380.         EXITIF count=0 DO PrintF('\n')
  381.             PrintF(',\n\t\t')
  382.             IF CtrlC() THEN RETURN
  383.         ENDWHILE
  384.     ENDIF
  385.  
  386.     IF Long(mem)="HEAD"
  387.         nl:=Word(mem+4)
  388.         mem+=6
  389.         PrintF('OPT\tHEAD=''\s''\n',mem)
  390.         mem+=nl
  391.         IF Odd(nl) THEN mem++
  392.     ENDIF
  393.  
  394. ENDPROC
  395.  
  396. PROC LoadOBJECT(mem:PTR TO CHAR,nmem:PTR TO CHAR)(PTR TO CHAR,PTR TO CHAR)
  397.     IF mem[0]=0
  398.         PrintF('OBJECT \s',nmem)
  399.         nmem+=mem[1]+1
  400.         IF mem[2]
  401.             PrintF(' OF \s\n',nmem)
  402.             nmem+=mem[2]+1
  403.         ELSE PrintF('\n')
  404.         mem+=8
  405.         WHILE mem[0]=1
  406.             mem,nmem:=LoadOBJECT(mem,nmem)
  407.         ELSEWHILE mem[0]=2
  408.             mem,nmem:=LoadOBJECT(mem,nmem)
  409.         ALWAYS
  410.         EXITIF mem[0]<>1 AND mem[0]<>2 DO PrintF('\n\n')
  411.             PrintF(',\n')
  412.             IF CtrlC() THEN RETURN
  413.         ENDWHILE
  414.     ELSEIF mem[0]=1
  415.         PrintF('\t\s',nmem)
  416.         nmem+=mem[1]+1
  417.         IF Word(mem+6) THEN PrintF('[\d]',Word(mem+6))
  418.         PrintF(':\s',TypeStr(mem[2]))
  419.         IF mem[5]
  420.             PrintF('\s',nmem)
  421.             nmem+=mem[5]+1
  422.         ENDIF
  423.         mem+=10
  424.     ELSEIF mem[0]=2
  425.         DEF    count,first=TRUE
  426.         WHILE mem[0]=2
  427.             PrintF('\t\s \s\n',IF first THEN 'OBJECT' ELSE 'UNION',nmem)
  428.             nmem+=mem[1]+1
  429.             count:=mem[2]
  430.             mem+=6
  431.             WHILE count
  432.                 count--
  433.                 PrintF('\t')
  434.                 mem,nmem:=LoadOBJECT(mem,nmem)
  435.                 PrintF(IF mem[0]=1 AND count>0 THEN ',\n' ELSE '\n')
  436.                 IF CtrlC() THEN RETURN
  437.             ENDWHILE
  438.             first:=FALSE
  439.         ENDWHILE
  440.         PrintF('\tENDOBJECT')
  441.     ENDIF
  442. ENDPROC mem,nmem
  443.  
  444. PROC TypeStr(type)(PTR TO CHAR)
  445.     DEF    str:PTR TO CHAR
  446.     SELECT type
  447.     CASE 1;    str:='LONG'
  448.     CASE 2;    str:='ULONG'
  449.     CASE 3;    str:='WORD'
  450.     CASE 4;    str:='UWORD'
  451.     CASE 5;    str:='BYTE'
  452.     CASE 6;    str:='UBYTE'
  453.     CASE 7;    str:='FLOAT'
  454.     CASE 8;    str:='DOUBLE'
  455.     CASE 9;    str:='BOOL'
  456.     CASE 10;    str:=NIL
  457.     CASE 11;    str:='PTR'
  458.     CASE 12;    str:='DLONG'
  459.     CASE 13;    str:='UDLONG'
  460.     CASE 14;    str:='STRING'
  461.  
  462.     CASE 33;    str:='PTR TO LONG'
  463.     CASE 34;    str:='PTR TO ULONG'
  464.     CASE 35;    str:='PTR TO WORD'
  465.     CASE 36;    str:='PTR TO UWORD'
  466.     CASE 37;    str:='PTR TO BYTE'
  467.     CASE 38;    str:='PTR TO UBYTE'
  468.     CASE 39;    str:='PTR TO FLOAT'
  469.     CASE 40;    str:='PTR TO DOUBLE'
  470.     CASE 41;    str:='PTR TO BOOL'
  471.     CASE 42;    str:='PTR TO '
  472.     CASE 43;    str:='PTR TO PTR'
  473.     CASE 44;    str:='PTR TO DLONG'
  474.     CASE 45;    str:='PTR TO UDLONG'
  475.     CASE 46;    str:='PTR TO CHAR'
  476.  
  477.     CASE 65;    str:='PTR TO PTR TO LONG'
  478.     CASE 66;    str:='PTR TO PTR TO ULONG'
  479.     CASE 67;    str:='PTR TO PTR TO WORD'
  480.     CASE 68;    str:='PTR TO PTR TO UWORD'
  481.     CASE 69;    str:='PTR TO PTR TO BYTE'
  482.     CASE 70;    str:='PTR TO PTR TO UBYTE'
  483.     CASE 71;    str:='PTR TO PTR TO FLOAT'
  484.     CASE 72;    str:='PTR TO PTR TO DOUBLE'
  485.     CASE 73;    str:='PTR TO PTR TO BOOL'
  486.     CASE 74;    str:='PTR TO PTR TO '
  487.     CASE 75;    str:='PTR TO PTR TO PTR'
  488.     CASE 76;    str:='PTR TO PTR TO DLONG'
  489.     CASE 77;    str:='PTR TO PTR TO UDLONG'
  490.     CASE 78;    str:='PTR TO PTR TO CHAR'
  491.  
  492.     CASE 129;str:='LIST OF LONG'
  493.     CASE 130;str:='LIST OF ULONG'
  494.     CASE 131;str:='LIST OF WORD'
  495.     CASE 132;str:='LIST OF UWORD'
  496.     CASE 133;str:='LIST OF BYTE'
  497.     CASE 134;str:='LIST OF UBYTE'
  498.     CASE 135;str:='LIST OF FLOAT'
  499.     CASE 136;str:='LIST OF DOUBLE'
  500.     CASE 137;str:='LIST OF BOOL'
  501.     CASE 138;str:='LIST OF '
  502.     CASE 139;str:='LIST OF PTR'
  503.     CASE 140;str:='LIST OF DLONG'
  504.     CASE 141;str:='LIST OF UDLONG'
  505.     CASE 142;str:='LIST OF CHAR'
  506.     DEFAULT;    str:='VOID'
  507.     ENDSELECT
  508. ENDPROC str
  509.  
  510. MODULE    'exec/memory'
  511.  
  512. ENUM    SOURCE
  513.  
  514. PROC main()
  515.     DEF    rda,args=[0,0]:LONG,l,m:PTR TO CHAR,f
  516.     IF rda:=ReadArgs('SOURCE/A',args,NIL)
  517.         l:=FileLength(args[SOURCE])
  518.         IF f:=Open(args[SOURCE],OLDFILE)
  519.             IF m:=AllocMem(l+8,MEMF_PUBLIC|MEMF_CLEAR)
  520.                 IF Read(f,m,l)=l
  521.                     DisplayMODULE(m)
  522.                 ELSE PrintFault(IOErr(),'dmod')
  523.                 FreeMem(m,l+8)
  524.             ELSE PrintF('\s: not enough memory\n','dmod')
  525.             Close(f)
  526.         ELSE PrintFault(IOErr(),'dmod')
  527.         FreeArgs(rda)
  528.     ELSE PrintFault(IOErr(),'dmod')
  529. ENDPROC
  530.